home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / netextensions.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  11.7 KB  |  421 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import urllib
  5. import base64
  6. import mimetools
  7. import os
  8. import time
  9. import httplib
  10. import os
  11. if os.name == 'nt':
  12.     from msvcrt import get_osfhandle
  13.     from ctypes import windll, WinError
  14.     SetHandleInformation = windll.kernel32.SetHandleInformation
  15.     
  16.     def set_noninheritable(socket):
  17.         SetHandleInformation(socket.fileno(), 1, 0)
  18.  
  19.     import socket
  20.     original_socket = socket.socket
  21.     _orig_connect = original_socket.connect
  22.     _orig_connect_ex = original_socket.connect_ex
  23.     _orig_accept = original_socket.accept
  24.     
  25.     def connect(self, address):
  26.         res = _orig_connect(self, address)
  27.         set_noninheritable(self)
  28.         return res
  29.  
  30.     
  31.     def connect_ex(self, address):
  32.         res = _orig_connect_ex(self, address)
  33.         set_noninheritable(self)
  34.         return res
  35.  
  36.     
  37.     def accept(self):
  38.         (conn, addr) = _orig_accept(self)
  39.         set_noninheritable(conn)
  40.         return (conn, addr)
  41.  
  42.     original_socket.connect = connect
  43.     original_socket.connect_ex = connect_ex
  44.     original_socket.accept = accept
  45.  
  46.  
  47. def open_data(self, url, data = None):
  48.     if not isinstance(url, str):
  49.         raise IOError, ('data error', 'proxy support for data protocol currently not implemented')
  50.     
  51.     
  52.     try:
  53.         StringIO = StringIO
  54.         import cStringIO
  55.     except ImportError:
  56.         StringIO = StringIO
  57.         import StringIO
  58.  
  59.     
  60.     try:
  61.         (type, data) = url.split(',', 1)
  62.     except ValueError:
  63.         raise IOError, ('data error', 'bad data URL')
  64.  
  65.     if not type:
  66.         type = 'text/plain;charset=US-ASCII'
  67.     
  68.     semi = type.rfind(';')
  69.     if semi >= 0 and '=' not in type[semi:]:
  70.         encoding = type[semi + 1:]
  71.         type = type[:semi]
  72.     else:
  73.         encoding = ''
  74.     msg = []
  75.     msg.append('Date: %s' % time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime(time.time())))
  76.     msg.append('Content-type: %s' % type)
  77.     if encoding == 'base64':
  78.         data = base64.decodestring(data)
  79.     else:
  80.         data = urllib.unquote(data)
  81.     msg.append('Content-Length: %d' % len(data))
  82.     msg.append('')
  83.     msg.append(data)
  84.     msg = '\n'.join(msg)
  85.     f = StringIO(msg)
  86.     headers = mimetools.Message(f, 0)
  87.     return urllib.addinfourl(f, headers, url)
  88.  
  89. urllib.URLopener.open_data = open_data
  90.  
  91. def ab___init__(self, fp):
  92.     self.fp = fp
  93.     self._amt_read = 0
  94.     if hasattr(self.fp, 'readlines'):
  95.         self.readlines = self.fp.readlines
  96.     
  97.     if hasattr(self.fp, 'fileno'):
  98.         self.fileno = self.fp.fileno
  99.     else:
  100.         
  101.         self.fileno = lambda : pass
  102.     if hasattr(self.fp, '__iter__'):
  103.         self.__iter__ = self.fp.__iter__
  104.         if hasattr(self.fp, 'next'):
  105.             self.next = self.fp.next
  106.         
  107.     
  108.  
  109.  
  110. def ab_read(self, *a, **k):
  111.     v = self.fp.read(*a, **k)
  112.     self._amt_read += len(v)
  113.     return v
  114.  
  115.  
  116. def ab_readline(self, *a, **k):
  117.     v = self.fp.readline(*a, **k)
  118.     self._amt_read += len(v)
  119.     return v
  120.  
  121.  
  122. def ab_tell(self):
  123.     return self._amt_read
  124.  
  125.  
  126. def ab___repr__(self):
  127.     return '<%s at %r whose fp = %r>' % (self.__class__.__name__, id(self), self.fp)
  128.  
  129.  
  130. def ab_close(self):
  131.     self._amt_read = 0
  132.     self.read = None
  133.     self.readline = None
  134.     self.readlines = None
  135.     self.fileno = None
  136.     if self.fp:
  137.         self.fp.close()
  138.     
  139.     self.fp = None
  140.  
  141. for meth in '__init__ read readline tell __repr__ close'.split():
  142.     setattr(urllib.addbase, meth, globals()['ab_' + meth])
  143.  
  144. if os.name == 'nt':
  145.     
  146.     class OneProxy(dict):
  147.         
  148.         def proxyServer(self):
  149.             return self._proxyServer
  150.  
  151.         proxyServer = property(proxyServer)
  152.         
  153.         def __missing__(self, key):
  154.             val = '%s://%s' % (key, self.proxyServer)
  155.             self.__setitem__(key, val)
  156.             return val
  157.  
  158.  
  159.     
  160.     def getproxies_registry():
  161.         proxies = { }
  162.         
  163.         try:
  164.             import _winreg
  165.         except ImportError:
  166.             return proxies
  167.  
  168.         
  169.         try:
  170.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings')
  171.             proxyEnable = _winreg.QueryValueEx(internetSettings, 'ProxyEnable')[0]
  172.             if proxyEnable:
  173.                 proxyServer = str(_winreg.QueryValueEx(internetSettings, 'ProxyServer')[0])
  174.                 if '=' in proxyServer:
  175.                     for p in proxyServer.split(';'):
  176.                         (protocol, address) = p.split('=', 1)
  177.                         import re
  178.                         if not re.match('^([^/:]+)://', address):
  179.                             address = '%s://%s' % (protocol, address)
  180.                         
  181.                         proxies[protocol] = address
  182.                     
  183.                 elif proxyServer[:5] == 'http:':
  184.                     proxies['http'] = proxyServer
  185.                 else:
  186.                     proxies = OneProxy()
  187.                     proxies._proxyServer = proxyServer
  188.                     proxies['https']
  189.                     proxies['http']
  190.                     proxies['ftp']
  191.             
  192.             internetSettings.Close()
  193.         except (WindowsError, ValueError, TypeError):
  194.             pass
  195.  
  196.         return proxies
  197.  
  198.     urllib.OneProxy = OneProxy
  199.     urllib.getproxies_registry = getproxies_registry
  200.  
  201. import urllib2
  202.  
  203. class ProxyHandler(urllib2.BaseHandler):
  204.     handler_order = 100
  205.     
  206.     def __init__(self, proxies = None):
  207.         self._proxies = proxies
  208.         for type in ('http', 'https', 'ftp'):
  209.             setattr(self, '%s_open' % type, (lambda r, type = type, meth = self.proxy_open: meth(r, type)))
  210.         
  211.  
  212.     
  213.     def _get_proxies(self):
  214.         import urllib
  215.         if not self._proxies:
  216.             pass
  217.         return urllib.getproxies()
  218.  
  219.     
  220.     def _set_proxies(self, val):
  221.         self._proxies = val
  222.  
  223.     proxies = property(_get_proxies, _set_proxies)
  224.     
  225.     def proxy_open(self, req, type):
  226.         orig_type = req.get_type()
  227.         
  228.         try:
  229.             proxy = self.proxies[type]
  230.         except KeyError:
  231.             return None
  232.  
  233.         (proxy_type, user, password, hostport) = urllib2._parse_proxy(proxy)
  234.         if proxy_type is None:
  235.             proxy_type = orig_type
  236.         
  237.         if user and password:
  238.             user_pass = '%s:%s' % (urllib2.unquote(user), urllib2.unquote(password))
  239.             creds = base64.b64encode(user_pass).strip()
  240.             req.add_header('Proxy-Authorization', 'Basic ' + creds)
  241.         
  242.         hostport = urllib2.unquote(hostport)
  243.         req.set_proxy(hostport, proxy_type)
  244.         if orig_type == proxy_type:
  245.             return None
  246.         else:
  247.             return self.parent.open(req)
  248.  
  249.  
  250. urllib2.ProxyHandler = ProxyHandler
  251.  
  252. def _no_ftp_file_open(self, req):
  253.     return self.open_local_file(req)
  254.  
  255. urllib2.FileHandler.file_open = _no_ftp_file_open
  256. urllib2.default_opener_classes = map((lambda x: getattr(urllib2, x)), ('UnknownHandler', 'HTTPHandler', 'HTTPDefaultErrorHandler', 'HTTPRedirectHandler', 'FTPHandler', 'FileHandler', 'HTTPErrorProcessor'))
  257.  
  258. def build_opener(*handlers, **kwds):
  259.     import types
  260.     opener_class = kwds.pop('opener_class', urllib2.OpenerDirector)
  261.     classes = kwds.pop('default_classes', urllib2.default_opener_classes)[:]
  262.     if kwds:
  263.         raise TypeError('Only opener_class and default_classes are accepted as keyword arguments for build_opener')
  264.     
  265.     
  266.     def isclass(obj):
  267.         if not isinstance(obj, types.ClassType):
  268.             pass
  269.         return hasattr(obj, '__bases__')
  270.  
  271.     opener = opener_class()
  272.     if hasattr(httplib, 'HTTPS'):
  273.         classes.append(urllib2.HTTPSHandler)
  274.     
  275.     skip = []
  276.     for klass in classes:
  277.         for check in handlers:
  278.             if isclass(check):
  279.                 if isclass(klass) and issubclass(check, klass):
  280.                     skip.append(klass)
  281.                 elif not isclass(klass) and issubclass(check, type(klass)):
  282.                     skip.append(klass)
  283.                 
  284.             issubclass(check, type(klass))
  285.             if isinstance(check, type(klass)):
  286.                 skip.append(klass)
  287.                 continue
  288.             if isclass(klass) and isinstance(check, klass):
  289.                 skip.append(klass)
  290.                 continue
  291.         
  292.     
  293.     for klass in skip:
  294.         classes.remove(klass)
  295.     
  296.     for klass in classes:
  297.         
  298.         try:
  299.             instance = klass()
  300.         except (AttributeError, TypeError):
  301.             instance = klass
  302.  
  303.         opener.add_handler(instance)
  304.     
  305.     for h in handlers:
  306.         if isclass(h):
  307.             h = h()
  308.         
  309.         opener.add_handler(h)
  310.     
  311.     return opener
  312.  
  313. urllib2.build_opener = build_opener
  314. import socket
  315. from asynchat import find_prefix_at_end
  316.  
  317. def handle_read(self):
  318.     
  319.     try:
  320.         data = self.recv(self.ac_in_buffer_size)
  321.     except socket.error:
  322.         why = None
  323.         self.handle_error(why)
  324.         return None
  325.  
  326.     self.ac_in_buffer = self.ac_in_buffer + data
  327.     while self.ac_in_buffer:
  328.         lb = len(self.ac_in_buffer)
  329.         terminator = self.get_terminator()
  330.         if not terminator:
  331.             self.collect_incoming_data(self.ac_in_buffer)
  332.             self.ac_in_buffer = ''
  333.             continue
  334.         if isinstance(terminator, int) or isinstance(terminator, long):
  335.             n = terminator
  336.             if lb < n:
  337.                 self.collect_incoming_data(self.ac_in_buffer)
  338.                 self.ac_in_buffer = ''
  339.                 self.terminator = self.terminator - lb
  340.             else:
  341.                 self.collect_incoming_data(self.ac_in_buffer[:n])
  342.                 self.ac_in_buffer = self.ac_in_buffer[n:]
  343.                 self.terminator = 0
  344.                 self.found_terminator()
  345.         lb < n
  346.         terminator_len = len(terminator)
  347.         index = self.ac_in_buffer.find(terminator)
  348.         if index != -1:
  349.             if index > 0:
  350.                 self.collect_incoming_data(self.ac_in_buffer[:index])
  351.             
  352.             self.ac_in_buffer = self.ac_in_buffer[index + terminator_len:]
  353.             self.found_terminator()
  354.             continue
  355.         index = find_prefix_at_end(self.ac_in_buffer, terminator)
  356.         if index:
  357.             if index != lb:
  358.                 self.collect_incoming_data(self.ac_in_buffer[:-index])
  359.                 self.ac_in_buffer = self.ac_in_buffer[-index:]
  360.             
  361.             break
  362.             continue
  363.         self.collect_incoming_data(self.ac_in_buffer)
  364.         self.ac_in_buffer = ''
  365.  
  366.  
  367. def initiate_send(self):
  368.     obs = self.ac_out_buffer_size
  369.     if len(self.ac_out_buffer) < obs:
  370.         self.refill_buffer()
  371.     
  372.     if self.ac_out_buffer and self.connected:
  373.         
  374.         try:
  375.             num_sent = self.send(self.ac_out_buffer[:obs])
  376.             if num_sent:
  377.                 self.ac_out_buffer = self.ac_out_buffer[num_sent:]
  378.         except socket.error:
  379.             why = None
  380.             self.handle_error(why)
  381.             return None
  382.         except:
  383.             None<EXCEPTION MATCH>socket.error
  384.         
  385.  
  386.     None<EXCEPTION MATCH>socket.error
  387.  
  388. import asynchat
  389. asynchat.async_chat.handle_read = handle_read
  390. asynchat.async_chat.initiate_send = initiate_send
  391. del handle_read
  392. del initiate_send
  393.  
  394. def make_request(cls, full_url, data = None, *a, **k):
  395.     if not isinstance(full_url, cls):
  396.         default_host = k.pop('default_host', None)
  397.         ssl = k.pop('ssl', False)
  398.         proto = None % 'http%s' if ssl else ''
  399.         if default_host:
  400.             if not full_url.startswith(proto):
  401.                 pass
  402.             if not full_url.startswith(default_host):
  403.                 proto_host = '%s://%s' % (proto, default_host.rstrip('/'))
  404.                 full_url = proto_host + '/' + full_url.lstrip('/')
  405.             
  406.         if not full_url.startswith(proto):
  407.             full_url = '%s://%s' % (proto, full_url)
  408.         
  409.         req = cls(full_url, *a, **k)
  410.     else:
  411.         req = full_url
  412.     if data is not None:
  413.         if not isinstance(data, str):
  414.             data = urllib.urlencode(data)
  415.         
  416.         req.add_data(data)
  417.     
  418.     return req
  419.  
  420. urllib2.Request.make_request = classmethod(make_request)
  421.